*** Problems ***

What's 'e'?
How do I calculate the error?  I have a formula, but I don't know how to apply it.
I think that I'm going to have to put all of the stupid neural shit in a a class...


*** Shopping list ***

-Input:		1 array, degree of 25, for storing the values 1 and 0...
		it represents a 5x5 field upon which characters are mapped
		1 and 0 represent on and off, ie 1 tells if the block is colored in
-Hidden Layer:	1 array, degree of N, for storing 1's and 0's
		it represents the hidden layer, inbetween the Input and the Output
-Output:	1 variable, stores 1 or 0
		1 represents x, 0 represents T
-Input Weights:	1 array, degree of 25xN
		it represents the weights of each of the lines from the inputs to the Hidden layer
-Hidden Weights:1 array, degree of N

*** Plunkett's directions ***

1  Rand assign weights
2  Run 1st training set
3  Calculate error
4  Randomly adjust weights
5  Run first set
6  Calculate error
7  Keep set with lowest error
8  End first set -- add error to total error
9  Run second set with best error from first set
10 adjust weights randomly
11 run second training set
12 keep weight set with lowest error
13 add error to total error

*** My take on things ***

1  Randomly assign the first set of weights
2  Run first training pattern
3  Calculate error -- add to "1st set total error"
4  Run second training pattern
5  Calculate error -- add to "1st set total error"
6  Create the second set of weights by randomly adjusting the first
7  Run first training pattern
8  Calculate error -- add to "2nd set total error"
9  Run second training pattern
10 Calculate error -- add to "2nd set total error"
11 Compare errors -- take the lower of the two
12 Store better set as set one -- "1st set total error" = error of that set
13 Loop to step 6

>>> Running a Training Pattern
1  Set input equal to current pattern(X or T or something else)
2  Set n to zero
3  Set m to zero
4  Take input[n] and multiply it by weight[n][m] and add that quantity to hidden[m]
5  Increment m and loop to step 3 until m > the # of spots in the hidden layer(8)
6  Increment n and loop to step 2 until n > the # of spots in the input(25)
7  Add the bias(1) to each spot in the hidden layer
8  Adjust each spot in the hidden layer with:  1/(1+e^x), where x is the original value of the spot
9  set n to zero
10 set m to zero
11 Take hidden[n] and multiply it by hiddenwt[n][m] and add that quantity to output[m]
12 Increment m and loop to step 10 until m > the # of spots in the output(1)
13 Increment n and loop to step 9 until n > the # of spots in the hidden layer(8)
14 Adjust each spot in the output with: 1/(1+e^x), where x is the original value of the spot

*** Necessary Functions ***
Creation - 
 	Input:	None
 	Output:	None
 > Creates new neural net
Initialization
	Input:	None
	Output:	None
 > Randomly assigns current Wt Set
 > Initializes other variables
Run Pattern on current Wt Set:	
	Input:	Test pattern, expected output
	Output:	Error
 > Runs pattern on current Wt Set and returns the error as compared to the expected output
Run Pattern on Alt Wt Set:	
	Input:  Test pattern, expected output
	Output: Error
 > Runs pattern on Alt Wt Set and returns the error as compared to the expected output
Create Alt. Wt Set:
	Input: 	None
	Output:	None
 > Creates Alt Wt Set, which is based on modification of current Wt Set
Bump Set (spike):
	Input:	None
	Output:	T/F
 > Sets current Wt Set equal to Alt Wt Set